#include <iostream>
#include <cstring>
#include <vector>

class MyString {
public:
    // 构造函数
   explicit MyString(const char* str = "") {
        length = std::strlen(str);
        data = new char[length + 1];
        std::strcpy(data, str);
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        length = other.length;
        data = new char[length + 1];
        std::strcpy(data, other.data);
        std::cout << "Copy constructor called\n";
    }

    // 移动构造函数
    MyString(MyString&& other) noexcept {
        length = other.length;
        data = other.data;
        other.data = nullptr;
        other.length = 0;
        std::cout << "Move constructor called\n";
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    // 显示字符串内容
    void print() const {
        std::cout << data << std::endl;
    }

private:
    char* data;
    size_t length;
};

// 函数模板，接受右值引用
template<typename T>
void hello(T&& arg) {
    // 这里可以对参数进行处理，例如打印
    arg->print();
}

// 函数模板，接受右值引用
template<typename T>
void hello(T&arg) {
    // 这里可以对参数进行处理，例如打印
    arg->print();
}


// 函数模板，接受右值引用
template<typename T>
void process(T&& arg) {
    // 这里可以对参数进行处理，例如打印
   // arg.print();
    hello(std::forward<T&&>(arg));
}

//void show(MyString my) {
//    // 这里可以对参数进行处理，例如打印
//    // arg.print();
//}



int main() {
    MyString *s1 = new MyString("hello");
  //  MyString s2 = s1; // 调用拷贝构造函数
   // MyString s3(std::move(s1)); // 调用移动构造函数
   MyString s3("hello");

   // process(std::forward<MyString*>(new MyString("hello") )); // 调用 process 的左值版本
    //process(std::move(s3)); // 调用 process 的右值版本
   // std::vector<MyString> v;
   // v.emplace_back(s1);
   // v.emplace_back("hello world ssss");
    //v.push_back(std::move(s1));
    //show(std::move(s3));


    return 0;
}